﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;

namespace Noris.Schedule.Support
{
    public class Vector
    {
        #region KONSTRUKCE, PROMĚNNÉ
        public Vector(PointF point1, PointF point2)
        {
            this._Point1X = (double)point1.X;
            this._Point1Y = (double)point1.Y;
            this._Point2X = (double)point2.X;
            this._Point2Y = (double)point2.Y;

            bool eqX = (this._Point1X == this._Point2X);
            bool eqY = (this._Point1Y == this._Point2Y);
            if (eqX && eqY)
                this._Bearing = _BearingType.Nul;
            else if (eqX && !eqY)
                this._Bearing = _BearingType.Vertical;
            else if (!eqX && eqY)
                this._Bearing = _BearingType.Horizontal;
            else
                this._Bearing = _BearingType.Diagonal;
        }
        private double _Point1X;
        private double _Point1Y;
        private double _Point2X;
        private double _Point2Y;
        private _BearingType _Bearing;
        #endregion
        #region PROPERTY
        private double _DX { get { return (this._Point2X - this._Point1X); } }
        private double _DY { get { return (this._Point2Y - this._Point1Y); } }
        #endregion
        /// <summary>
        /// Metoda najde průsečík(y) vektoru s daným obdélníkem.
        /// </summary>
        /// <param name="rect"></param>
        /// <param name="intersect1"></param>
        /// <param name="intersect2"></param>
        /// <returns></returns>
        public bool IntersectWithRectangle(RectangleF rect, out PointF intersect1, out PointF intersect2)
        {
            intersect1 = PointF.Empty;
            intersect2 = PointF.Empty;
            return false;
        }
        /// <summary>
        /// Metoda najde souřadnici Y, na které se tento vektor protíná s danou souřadnicí X.
        /// Pokud se neprotíná nikde (nebo všude), pak vrací not value.
        /// </summary>
        /// <param name="x"></param>
        /// <returns></returns>
        public float? IntersectWithX(float x)
        {
            float? result = null;
            switch (this._Bearing)
            {
                case _BearingType.Nul:
                    break;
                case _BearingType.Horizontal:
                    // Vektor běží vodorovně na konstantní souřadnici Y:
                    result = (float)this._Point1Y;
                    break;
                case _BearingType.Vertical:
                    // Vektor běží svisle na konstantní souřadnici X:
                    break;
                case _BearingType.Diagonal:
                    // Vektor běží šikmo, zcela jistě někde v jednom konkrétním bodě souřadnici X potká:
                    result = (float)(this._DY / this._DX * (x - this._Point1X) + this._Point1Y);  // dy / dx = směrník (úhel), x - point1X = vzdálenost vstupující souřadnice X od bodu 1, výsledek = po přičtění souřadnice bodu 1 Y
                    break;
            }
            return result;
        }
        /// <summary>
        /// Metoda najde souřadnici X, na které se tento vektor protíná s danou souřadnicí Y.
        /// Pokud se neprotíná nikde (nebo všude), pak vrací not value.
        /// </summary>
        /// <param name="y"></param>
        /// <returns></returns>
        public float? IntersectWithY(float y)
        {
            float? result = null;
            switch (this._Bearing)
            {
                case _BearingType.Nul:
                    break;
                case _BearingType.Horizontal:
                    // Vektor běží vodorovně na konstantní souřadnici Y:
                    break;
                case _BearingType.Vertical:
                    // Vektor běží svisle na konstantní souřadnici X:
                    result = (float)this._Point1X;
                    break;
                case _BearingType.Diagonal:
                    // Vektor běží šikmo, zcela jistě někde v jednom konkrétním bodě souřadnici Y potká:
                    result = (float)(this._DX / this._DY * (y - this._Point1Y) + this._Point1X);  // dx / dy = směrník (úhel), y - point1Y = vzdálenost vstupující souřadnice Y od bodu 1, výsledek = po přičtění souřadnice bodu 1 X
                    break;
            }
            return result;
        }
        #region ENUM _BearingType (Směr vektoru, pro snadnější zpracování mezních stavů)
        /// <summary>
        /// Směr vektoru, pro snadnější zpracování mezních stavů
        /// </summary>
        private enum _BearingType
        {
            /// <summary>Nedefinovaný vektor (bod 1 == bod 2)</summary>
            Nul,
            /// <summary>Vodorovný vektor, souběžný s osou X, souřadnice Y se nemění</summary>
            Horizontal,
            /// <summary>Svislý vektor, souběžný s osou Y, souřadnice X se nemění</summary>
            Vertical,
            /// <summary>Diagonální vektor, mění se obě souřadnice</summary>
            Diagonal
        }
        #endregion
    }
}
